package com.szml.controller;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.szml.constants.RedisConstants;
import com.szml.dto.ProductDTO;
import com.szml.dto.ProductPageDTO;
import com.szml.entity.ProductBasic;
import com.szml.result.PageResult;
import com.szml.result.Result;
import com.szml.service.ProductBasicService;
import com.szml.vo.ProductVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/product")
@Slf4j
public class ProductController {


    @Autowired
    private ProductBasicService productBasicService;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 商品基本信息条件分页查询
     * @param productPageDTO
     * @return
     */
    @GetMapping("/page")
    public Result<PageResult> productConditionSearch(ProductPageDTO productPageDTO){
        log.info("商品基本信息条件分页查询,{}",productPageDTO);
        return Result.success(productBasicService.conditionSearch(productPageDTO));
    }

    /**
     * 根据id查询商品详情
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public Result<ProductVO> productDetail(@PathVariable Long id){
        log.info("根据id查询商品详情：{}",id);
        /**
         * 查缓存，成功就返回
         * 失败就查数据库
         * （穿透问题已解决缓存null）
         * **/
        //获取redis的key
        String key= RedisConstants.CACHE_SHOP_KEY+id;

        //先查询缓存是否存在该商品的信息
        String productdetailsJson=stringRedisTemplate.opsForValue().get(key);
        //判断是否存在isNotBlank空字符串也是false
        if (StrUtil.isNotBlank(productdetailsJson))
        {
            //存在就直接返回
            ProductVO productVO= JSONUtil.toBean(productdetailsJson,ProductVO.class);
            return Result.success(productVO);
        }
        if (productdetailsJson!=null)
        {
            //返回空值
            return Result.error("商品信息不存在");
        }

        //不成功查数据库
        ProductVO productVO=productBasicService.getProductById(id);
        //不存在返回错误
        if (productVO==null)
        {
            //设置为null值，过期时间设置为1分钟
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.PRODUCT_NULL_TTL,TimeUnit.MINUTES);
            //返回空值
            return Result.error("商品信息不存在");
        }
        // 随机选择一个过期时间
        int ttl = RedisConstants.TTL_IN_MINUTES[(int) (Math.random() * RedisConstants.TTL_IN_MINUTES.length)];

        //存在写入存储缓存//设置过期时间
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(productVO),ttl, TimeUnit.MINUTES);

        //返回
        return Result.success(productVO);
    }
    /**
     * 新增商品
     */
    @PostMapping
    public Result createProduct(@RequestBody ProductDTO productDTO) {
        log.info("新增商品:{}", productDTO);
        productBasicService.createProduct(productDTO);
        return Result.success();
    }
    /**
     * 删除所有商品
     *
     */
    /**
     * 删除缓存解决数据一致性问题
     * **/
    @DeleteMapping("/deleteAll")
    public Result deleteAll(@RequestParam("ids") Long[] ids)
    {
        Result result= productBasicService.deleteAll(ids);
        /**
         * 删除缓存
         * **/
        for (Long id : ids) {
            //拼接key并删除缓存
            String key = RedisConstants.CACHE_SHOP_KEY + id;
            stringRedisTemplate.delete(key);
        }

        return result;
    }

    /**
     * 修改商品信息
     * @param productDTO
     * @return
     */
    @PutMapping
    @Transactional
    public Result updateProduct(@RequestBody ProductDTO productDTO) {
        /**
         * 先更新数据库再删除缓存
         * **/
        log.info("修改商品:{}", productDTO);
        Result result = productBasicService.updateProduct(productDTO);
        /**
         * 删除缓存
         *
         * **/
        //储存商品基本信息，以获取id
        ProductBasic productBasic = new ProductBasic();
        BeanUtils.copyProperties(productDTO, productBasic);
        Long productId=productBasic.getProductId();
        if (productId==null)
        {
            return Result.error("商品信息不存在");
        }
        //拼接key并删除缓存
        String key=RedisConstants.CACHE_SHOP_KEY+productId;
        stringRedisTemplate.delete(key);
        return result;
    }


    /**
     * 上、下线功能 （一键上下线）
     * **/
    @PutMapping("/online/{status}")
    public Result onlineall(@PathVariable int status ,@RequestParam("ids") Long[] ids)
    {
        return productBasicService.onlineall(status,ids);
    }

    /**
     *
     * 商品审核操作
     * **/
    @PutMapping("/check/{status}")
    public Result checkproduct(@PathVariable int status ,@RequestParam("id") Long id)
    {
        return productBasicService.checkproduct(status,id);
    }
//    @GetMapping("/page")
//    public R<Page> page(int page, int pageSize, int pDetailId){
//        log.info("page = {},pageSize = {},productname = {}" ,page,pageSize,pDetailId);
//        //构造分页构造器
//        Page pageInfo = new Page(page,pageSize);
//        //构造条件构造器
//        LambdaQueryWrapper<ProductDetails> queryWrapper = new LambdaQueryWrapper();
//        //添加过滤条件
//        queryWrapper.like(StringUtils.isNotEmpty(String.valueOf(pDetailId)),ProductDetails::getProductName,pDetailId);
//        //添加排序条件
//        queryWrapper.orderByDesc(ProductDetails::getPDetailId);
//        //执行查询
//        merchantService.page(pageInfo,queryWrapper);
//        return R.success(pageInfo);
//    }
}
